package parser

import (
	"fmt"
	"strings"
)

// SymbolType 表示符号类型
type SymbolType int

const (
	TableSymbol SymbolType = iota
	ColumnSymbol
	AliasSymbol
	FunctionSymbol
	VariableSymbol
)

// Symbol 表示符号表中的一个符号
type Symbol struct {
	Name       string
	Type       SymbolType
	DataType   string // 数据类型（对于列）
	Table      string // 所属表（对于列）
	Definition Node   // 定义节点
}

// Scope 表示作用域
type Scope struct {
	Parent  *Scope
	Symbols map[string]*Symbol
	Level   int
}

// NewScope 创建新的作用域
func NewScope(parent *Scope) *Scope {
	level := 0
	if parent != nil {
		level = parent.Level + 1
	}
	return &Scope{
		Parent:  parent,
		Symbols: make(map[string]*Symbol),
		Level:   level,
	}
}

// AddSymbol 添加符号到当前作用域
func (s *Scope) AddSymbol(symbol *Symbol) error {
	if _, exists := s.Symbols[symbol.Name]; exists {
		return fmt.Errorf("symbol '%s' already defined in current scope", symbol.Name)
	}
	s.Symbols[symbol.Name] = symbol
	return nil
}

// LookupSymbol 在作用域链中查找符号
func (s *Scope) LookupSymbol(name string) *Symbol {
	if symbol, exists := s.Symbols[name]; exists {
		return symbol
	}
	if s.Parent != nil {
		return s.Parent.LookupSymbol(name)
	}
	return nil
}

// LookupSymbolInCurrentScope 仅在当前作用域查找符号
func (s *Scope) LookupSymbolInCurrentScope(name string) *Symbol {
	if symbol, exists := s.Symbols[name]; exists {
		return symbol
	}
	return nil
}

// SemanticError 表示语义错误
type SemanticError struct {
	Message string
	Node    Node
}

func (e *SemanticError) Error() string {
	return e.Message
}

// SemanticAnalyzer 语义分析器
type SemanticAnalyzer struct {
	CurrentScope    *Scope
	GlobalScope     *Scope
	Errors          []*SemanticError
	Tables          map[string]*TableSchema // 数据库表模式信息
	TypeInference   *TypeInferenceEngine    // 类型推断引擎
	ConstantFolder  *ConstantFolder         // 常量折叠器
}

// TableSchema 表示表的模式信息
type TableSchema struct {
	Name    string
	Columns map[string]*ColumnSchema
}

// ColumnSchema 表示列的模式信息
type ColumnSchema struct {
	Name     string
	DataType string
	NotNull  bool
	Primary  bool
	Unique   bool
}

// NewSemanticAnalyzer 创建新的语义分析器
func NewSemanticAnalyzer() *SemanticAnalyzer {
	globalScope := NewScope(nil)
	analyzer := &SemanticAnalyzer{
		CurrentScope: globalScope,
		GlobalScope:  globalScope,
		Errors:       make([]*SemanticError, 0),
		Tables:       make(map[string]*TableSchema),
	}
	analyzer.TypeInference = NewTypeInferenceEngine(analyzer)
	analyzer.ConstantFolder = NewConstantFolder()
	return analyzer
}

// AddTable 添加表模式信息
func (sa *SemanticAnalyzer) AddTable(name string, schema *TableSchema) {
	sa.Tables[name] = schema
	// 将表添加到全局作用域
	symbol := &Symbol{
		Name: name,
		Type: TableSymbol,
	}
	sa.GlobalScope.AddSymbol(symbol)
}

// GetTable 获取表模式信息
func (sa *SemanticAnalyzer) GetTable(name string) *TableSchema {
	return sa.Tables[name]
}

// AddError 添加语义错误
func (sa *SemanticAnalyzer) AddError(message string, node Node) {
	sa.Errors = append(sa.Errors, &SemanticError{
		Message: message,
		Node:    node,
	})
}

// EnterScope 进入新作用域
func (sa *SemanticAnalyzer) EnterScope() {
	sa.CurrentScope = NewScope(sa.CurrentScope)
}

// ExitScope 退出当前作用域
func (sa *SemanticAnalyzer) ExitScope() {
	if sa.CurrentScope.Parent != nil {
		sa.CurrentScope = sa.CurrentScope.Parent
	}
}

// AnalyzeStatement 分析语句
func (sa *SemanticAnalyzer) AnalyzeStatement(stmt Statement) error {
	switch s := stmt.(type) {
	case *SelectStmt:
		return sa.analyzeSelectStmt(s)
	case *InsertStmt:
		return sa.analyzeInsertStmt(s)
	case *UpdateStmt:
		return sa.analyzeUpdateStmt(s)
	case *DeleteStmt:
		return sa.analyzeDeleteStmt(s)
	case *CreateTableStmt:
		return sa.analyzeCreateTableStmt(s)
	default:
		return fmt.Errorf("unsupported statement type: %T", stmt)
	}
}

// analyzeSelectStmt 分析SELECT语句
func (sa *SemanticAnalyzer) analyzeSelectStmt(stmt *SelectStmt) error {
	// 进入新作用域
	sa.EnterScope()
	defer sa.ExitScope()

	// 首先分析FROM子句，建立表别名
	for _, tableRef := range stmt.From {
		if err := sa.analyzeTableRef(&tableRef); err != nil {
			return err
		}
	}

	// 分析SELECT目标列表
	for _, target := range stmt.Targets {
		if err := sa.analyzeExpression(target); err != nil {
			return err
		}
	}

	// 分析WHERE条件
	if stmt.Where != nil {
		if err := sa.analyzeExpression(stmt.Where); err != nil {
			return err
		}
	}

	// 分析GROUP BY子句
	for _, expr := range stmt.GroupBy {
		if err := sa.analyzeExpression(expr); err != nil {
			return err
		}
	}

	// 分析HAVING条件
	if stmt.Having != nil {
		if err := sa.analyzeExpression(stmt.Having); err != nil {
			return err
		}
	}

	// 分析ORDER BY子句
	for _, orderExpr := range stmt.OrderBy {
		if err := sa.analyzeExpression(orderExpr.Expr); err != nil {
			return err
		}
	}

	// 分析LIMIT和OFFSET
	if stmt.Limit != nil {
		if err := sa.analyzeExpression(stmt.Limit); err != nil {
			return err
		}
	}
	if stmt.Offset != nil {
		if err := sa.analyzeExpression(stmt.Offset); err != nil {
			return err
		}
	}

	return nil
}

// analyzeInsertStmt 分析INSERT语句
func (sa *SemanticAnalyzer) analyzeInsertStmt(stmt *InsertStmt) error {
	// 验证目标表是否存在
	if err := sa.analyzeTableRef(stmt.Table); err != nil {
		return err
	}

	tableSchema := sa.GetTable(stmt.Table.Name)
	if tableSchema == nil {
		sa.AddError(fmt.Sprintf("table '%s' does not exist", stmt.Table.Name), stmt.Table)
		return nil
	}

	// 验证列名
	for _, columnName := range stmt.Columns {
		if _, exists := tableSchema.Columns[columnName]; !exists {
			sa.AddError(fmt.Sprintf("column '%s' does not exist in table '%s'", columnName, stmt.Table.Name), stmt)
		}
	}

	// 分析VALUES子句
	for _, valueList := range stmt.Values {
		for _, value := range valueList {
			if err := sa.analyzeExpression(value); err != nil {
				return err
			}
		}
	}

	// 分析SELECT子句（如果存在）
	if stmt.Select != nil {
		if err := sa.analyzeSelectStmt(stmt.Select); err != nil {
			return err
		}
	}

	return nil
}

// analyzeUpdateStmt 分析UPDATE语句
func (sa *SemanticAnalyzer) analyzeUpdateStmt(stmt *UpdateStmt) error {
	// 进入新作用域
	sa.EnterScope()
	defer sa.ExitScope()

	// 验证目标表
	if err := sa.analyzeTableRef(stmt.Table); err != nil {
		return err
	}

	tableSchema := sa.GetTable(stmt.Table.Name)
	if tableSchema == nil {
		sa.AddError(fmt.Sprintf("table '%s' does not exist", stmt.Table.Name), stmt.Table)
		return nil
	}

	// 分析SET子句
	for _, setExpr := range stmt.Set {
		// 验证列名
		if _, exists := tableSchema.Columns[setExpr.Column]; !exists {
			sa.AddError(fmt.Sprintf("column '%s' does not exist in table '%s'", setExpr.Column, stmt.Table.Name), stmt)
		}
		// 分析值表达式
		if err := sa.analyzeExpression(setExpr.Value); err != nil {
			return err
		}
		
		// 进行赋值类型检查
		if err := sa.ValidateAssignment(setExpr.Column, setExpr.Value); err != nil {
			sa.AddError(err.Error(), stmt)
		}
	}

	// 分析WHERE条件
	if stmt.Where != nil {
		if err := sa.analyzeExpression(stmt.Where); err != nil {
			return err
		}
	}

	return nil
}

// analyzeDeleteStmt 分析DELETE语句
func (sa *SemanticAnalyzer) analyzeDeleteStmt(stmt *DeleteStmt) error {
	// 进入新作用域
	sa.EnterScope()
	defer sa.ExitScope()

	// 验证目标表
	if err := sa.analyzeTableRef(stmt.Table); err != nil {
		return err
	}

	// 分析WHERE条件
	if stmt.Where != nil {
		if err := sa.analyzeExpression(stmt.Where); err != nil {
			return err
		}
	}

	return nil
}

// analyzeCreateTableStmt 分析CREATE TABLE语句
func (sa *SemanticAnalyzer) analyzeCreateTableStmt(stmt *CreateTableStmt) error {
	// 检查表是否已存在
	if sa.GetTable(stmt.Table.Name) != nil {
		if !stmt.IfNotExists {
			sa.AddError(fmt.Sprintf("table '%s' already exists", stmt.Table.Name), stmt.Table)
		}
		return nil
	}

	// 创建表模式
	tableSchema := &TableSchema{
		Name:    stmt.Table.Name,
		Columns: make(map[string]*ColumnSchema),
	}

	// 分析列定义
	for _, columnDef := range stmt.Columns {
		columnSchema := &ColumnSchema{
			Name:     columnDef.Name,
			DataType: columnDef.Type.Name,
		}

		// 分析列约束
		for _, constraint := range columnDef.Constraints {
			switch constraint.Type {
			case NotNullConstraint:
				columnSchema.NotNull = true
			case PrimaryKeyConstraint:
				columnSchema.Primary = true
				columnSchema.NotNull = true
			case UniqueConstraint:
				columnSchema.Unique = true
			}
		}

		tableSchema.Columns[columnDef.Name] = columnSchema
	}

	// 添加表到分析器
	sa.AddTable(stmt.Table.Name, tableSchema)

	return nil
}

// analyzeTableRef 分析表引用
func (sa *SemanticAnalyzer) analyzeTableRef(tableRef *TableRef) error {
	// 验证表是否存在
	tableSchema := sa.GetTable(tableRef.Name)
	if tableSchema == nil {
		sa.AddError(fmt.Sprintf("table '%s' does not exist", tableRef.Name), tableRef)
		return nil
	}

	// 确定表的有效名称（别名或表名）
	effectiveName := tableRef.Name
	if tableRef.Alias != "" {
		effectiveName = tableRef.Alias
	}

	// 将表添加到当前作用域
	tableSymbol := &Symbol{
		Name: effectiveName,
		Type: TableSymbol,
	}
	sa.CurrentScope.AddSymbol(tableSymbol)

	// 将表的所有列添加到当前作用域
	for columnName, columnSchema := range tableSchema.Columns {
		// 添加完全限定的列名（表名.列名）
		qualifiedName := effectiveName + "." + columnName
		columnSymbol := &Symbol{
			Name:     qualifiedName,
			Type:     ColumnSymbol,
			DataType: columnSchema.DataType,
			Table:    effectiveName,
		}
		sa.CurrentScope.AddSymbol(columnSymbol)

		// 如果只有一个表，也添加非限定的列名
		if len(sa.CurrentScope.Symbols) == 1 || sa.isColumnNameUnique(columnName) {
			unqualifiedSymbol := &Symbol{
				Name:     columnName,
				Type:     ColumnSymbol,
				DataType: columnSchema.DataType,
				Table:    effectiveName,
			}
			sa.CurrentScope.AddSymbol(unqualifiedSymbol)
		}
	}

	// 分析JOIN表达式
	for _, joinExpr := range tableRef.Joins {
		if err := sa.analyzeJoinExpr(&joinExpr); err != nil {
			return err
		}
	}

	return nil
}

// analyzeJoinExpr 分析JOIN表达式
func (sa *SemanticAnalyzer) analyzeJoinExpr(joinExpr *JoinExpr) error {
	// 分析JOIN的表
	if err := sa.analyzeTableRef(joinExpr.Table); err != nil {
		return err
	}

	// 分析JOIN条件
	if joinExpr.Condition != nil {
		if err := sa.analyzeExpression(joinExpr.Condition); err != nil {
			return err
		}
	}

	return nil
}

// analyzeExpression 分析表达式
func (sa *SemanticAnalyzer) analyzeExpression(expr Expression) error {
	if expr == nil {
		return nil
	}

	switch e := expr.(type) {
	case *ColumnRef:
		return sa.analyzeColumnRef(e)
	case *Literal:
		// 字面量不需要名称解析
		return nil
	case *BinaryExpr:
		return sa.analyzeBinaryExpr(e)
	case *UnaryExpr:
		return sa.analyzeUnaryExpr(e)
	case *FunctionCall:
		return sa.analyzeFunctionCall(e)
	case *SubqueryExpr:
		return sa.analyzeSubqueryExpr(e)
	case *CaseExpr:
		return sa.analyzeCaseExpr(e)
	case *InExpr:
		return sa.analyzeInExpr(e)
	case *BetweenExpr:
		return sa.analyzeBetweenExpr(e)
	case *ExistsExpr:
		return sa.analyzeExistsExpr(e)
	default:
		// 对于其他表达式类型，暂时跳过
		return nil
	}
}

// analyzeColumnRef 分析列引用
func (sa *SemanticAnalyzer) analyzeColumnRef(columnRef *ColumnRef) error {
	var symbolName string
	if columnRef.Table != "" {
		// 完全限定的列名
		symbolName = columnRef.Table + "." + columnRef.Column
	} else {
		// 非限定的列名
		symbolName = columnRef.Column
	}

	symbol := sa.CurrentScope.LookupSymbol(symbolName)
	if symbol == nil {
		if columnRef.Table != "" {
			sa.AddError(fmt.Sprintf("column '%s.%s' does not exist", columnRef.Table, columnRef.Column), columnRef)
		} else {
			sa.AddError(fmt.Sprintf("column '%s' does not exist", columnRef.Column), columnRef)
		}
	}

	return nil
}

// analyzeBinaryExpr 分析二元表达式
func (sa *SemanticAnalyzer) analyzeBinaryExpr(expr *BinaryExpr) error {
	if err := sa.analyzeExpression(expr.Left); err != nil {
		return err
	}
	if err := sa.analyzeExpression(expr.Right); err != nil {
		return err
	}
	
	// 进行类型检查
	switch expr.Operator {
	case EQ, NE, LT, LE, GT, GE, LIKE, ILIKE, AND, OR:
		if err := sa.ValidateComparison(expr.Left, expr.Right, expr.Operator); err != nil {
			sa.AddError(err.Error(), expr)
		}
	case IS_NULL, IS_NOT_NULL:
		if err := sa.ValidateNullCheck(expr.Left, expr.Operator); err != nil {
			sa.AddError(err.Error(), expr)
		}
	case PLUS, MINUS, MULTIPLY, DIVIDE, MODULO:
		if err := sa.ValidateArithmetic(expr.Left, expr.Right, expr.Operator); err != nil {
			sa.AddError(err.Error(), expr)
		}
	case CONCAT:
		if err := sa.ValidateStringConcat(expr.Left, expr.Right); err != nil {
			sa.AddError(err.Error(), expr)
		}
	}
	
	// 常量折叠优化
	if folded := sa.ConstantFolder.FoldExpression(expr); folded != nil {
		// 如果可以折叠，检查返回的类型
		if binaryExpr, ok := folded.(*BinaryExpr); ok {
			*expr = *binaryExpr
		}
		// 如果折叠成了字面量，我们不能直接替换BinaryExpr
		// 这种情况下保持原表达式不变，让上层处理
	}
	
	return nil
}

// analyzeUnaryExpr 分析一元表达式
func (sa *SemanticAnalyzer) analyzeUnaryExpr(expr *UnaryExpr) error {
	return sa.analyzeExpression(expr.Operand)
}

// analyzeFunctionCall 分析函数调用
func (sa *SemanticAnalyzer) analyzeFunctionCall(expr *FunctionCall) error {
	// 分析函数参数
	for _, arg := range expr.Args {
		if err := sa.analyzeExpression(arg); err != nil {
			return err
		}
	}

	// 分析FILTER子句
	if expr.Filter != nil {
		if err := sa.analyzeExpression(expr.Filter); err != nil {
			return err
		}
	}

	// 分析ORDER BY子句
	for _, orderExpr := range expr.OrderBy {
		if err := sa.analyzeExpression(orderExpr.Expr); err != nil {
			return err
		}
	}

	// 进行函数调用类型检查
	if err := sa.ValidateFunctionCall(expr); err != nil {
		sa.AddError(err.Error(), expr)
	}

	// 常量折叠优化
	if folded := sa.ConstantFolder.FoldExpression(expr); folded != nil {
		// 如果可以折叠，检查返回的类型
		if funcCall, ok := folded.(*FunctionCall); ok {
			*expr = *funcCall
		}
		// 如果折叠成了字面量，我们不能直接替换FunctionCall
		// 这种情况下保持原表达式不变，让上层处理
	}

	return nil
}

// analyzeSubqueryExpr 分析子查询表达式
func (sa *SemanticAnalyzer) analyzeSubqueryExpr(expr *SubqueryExpr) error {
	return sa.analyzeSelectStmt(expr.Select)
}

// analyzeCaseExpr 分析CASE表达式
func (sa *SemanticAnalyzer) analyzeCaseExpr(expr *CaseExpr) error {
	if expr.Expr != nil {
		if err := sa.analyzeExpression(expr.Expr); err != nil {
			return err
		}
	}

	for _, whenClause := range expr.WhenList {
		if err := sa.analyzeExpression(whenClause.Condition); err != nil {
			return err
		}
		if err := sa.analyzeExpression(whenClause.Result); err != nil {
			return err
		}
	}

	if expr.Else != nil {
		if err := sa.analyzeExpression(expr.Else); err != nil {
			return err
		}
	}

	return nil
}

// analyzeInExpr 分析IN表达式
func (sa *SemanticAnalyzer) analyzeInExpr(expr *InExpr) error {
	if err := sa.analyzeExpression(expr.Expr); err != nil {
		return err
	}

	if expr.Subquery != nil {
		if err := sa.analyzeSubqueryExpr(expr.Subquery); err != nil {
			return err
		}
	} else {
		for _, listExpr := range expr.List {
			if err := sa.analyzeExpression(listExpr); err != nil {
				return err
			}
		}
	}

	return nil
}

// analyzeBetweenExpr 分析BETWEEN表达式
func (sa *SemanticAnalyzer) analyzeBetweenExpr(expr *BetweenExpr) error {
	if err := sa.analyzeExpression(expr.Expr); err != nil {
		return err
	}
	if err := sa.analyzeExpression(expr.Lower); err != nil {
		return err
	}
	if err := sa.analyzeExpression(expr.Upper); err != nil {
		return err
	}
	return nil
}

// analyzeExistsExpr 分析EXISTS表达式
func (sa *SemanticAnalyzer) analyzeExistsExpr(expr *ExistsExpr) error {
	return sa.analyzeSubqueryExpr(expr.Subquery)
}

// isColumnNameUnique 检查列名在当前作用域中是否唯一
func (sa *SemanticAnalyzer) isColumnNameUnique(columnName string) bool {
	count := 0
	for symbolName := range sa.CurrentScope.Symbols {
		if strings.HasSuffix(symbolName, "."+columnName) {
			count++
			if count > 1 {
				return false
			}
		}
	}
	return count <= 1
}

// HasErrors 检查是否有语义错误
func (sa *SemanticAnalyzer) HasErrors() bool {
	return len(sa.Errors) > 0
}

// GetErrors 获取所有语义错误
func (sa *SemanticAnalyzer) GetErrors() []*SemanticError {
	return sa.Errors
}

// ClearErrors 清除所有错误
func (sa *SemanticAnalyzer) ClearErrors() {
	sa.Errors = sa.Errors[:0]
}

// CheckTypeCompatibility 检查类型兼容性
func (sa *SemanticAnalyzer) CheckTypeCompatibility(sourceExpr, targetExpr Expression) error {
	sourceType := sa.TypeInference.InferExpressionType(sourceExpr)
	targetType := sa.TypeInference.InferExpressionType(targetExpr)
	
	if !sa.TypeInference.CheckTypeCompatibility(sourceType, targetType) {
		return fmt.Errorf("type mismatch: cannot convert %s to %s", sourceType.String(), targetType.String())
	}
	return nil
}

// InferExpressionType 推断表达式类型
func (sa *SemanticAnalyzer) InferExpressionType(expr Expression) *DataType {
	return sa.TypeInference.InferExpressionType(expr)
}

// ValidateAssignment 验证赋值操作的类型兼容性
func (sa *SemanticAnalyzer) ValidateAssignment(columnName string, valueExpr Expression) error {
	// 查找列的类型信息
	symbol := sa.CurrentScope.LookupSymbol(columnName)
	if symbol == nil || symbol.Type != ColumnSymbol {
		return fmt.Errorf("column '%s' not found", columnName)
	}
	
	// 获取列的数据类型
	columnType := sa.TypeInference.parseDataType(symbol.DataType)
	valueType := sa.TypeInference.InferExpressionType(valueExpr)
	
	// 检查类型兼容性
	if !sa.TypeInference.CheckTypeCompatibility(valueType, columnType) {
		return fmt.Errorf("type mismatch: cannot assign %s to column '%s' of type %s", 
			valueType.String(), columnName, columnType.String())
	}
	return nil
}

// ValidateComparison 验证比较操作的类型兼容性
func (sa *SemanticAnalyzer) ValidateComparison(leftExpr, rightExpr Expression, operator BinaryOp) error {
	leftType := sa.TypeInference.InferExpressionType(leftExpr)
	rightType := sa.TypeInference.InferExpressionType(rightExpr)
	
	// 对于比较操作符，两边的类型应该兼容
	switch operator {
	case EQ, NE, LT, LE, GT, GE:
		// 数值类型之间可以比较
		if sa.TypeInference.isNumericType(leftType) && sa.TypeInference.isNumericType(rightType) {
			return nil
		}
		// 字符串类型之间可以比较
		if sa.TypeInference.isStringType(leftType) && sa.TypeInference.isStringType(rightType) {
			return nil
		}
		// 相同类型可以比较
		if leftType.Name == rightType.Name {
			return nil
		}
		// 其中一个是UNKNOWN类型
		if leftType.Name == "UNKNOWN" || rightType.Name == "UNKNOWN" {
			return nil
		}
		return fmt.Errorf("cannot compare %s with %s", leftType.String(), rightType.String())
	
	case LIKE, ILIKE:
		// LIKE操作符要求两边都是字符串类型
		if !sa.TypeInference.isStringType(leftType) {
			return fmt.Errorf("LIKE operator requires string type on left side, got %s", leftType.String())
		}
		if !sa.TypeInference.isStringType(rightType) {
			return fmt.Errorf("LIKE operator requires string type on right side, got %s", rightType.String())
		}
		return nil
	
	case AND, OR:
		// 逻辑操作符要求两边都是布尔类型或可转换为布尔类型
		if leftType.Name != "BOOLEAN" && leftType.Name != "UNKNOWN" {
			return fmt.Errorf("logical operator requires boolean type on left side, got %s", leftType.String())
		}
		if rightType.Name != "BOOLEAN" && rightType.Name != "UNKNOWN" {
			return fmt.Errorf("logical operator requires boolean type on right side, got %s", rightType.String())
		}
		return nil
	
	default:
		return nil
	}
}

// ValidateArithmetic 验证算术操作的类型兼容性
func (sa *SemanticAnalyzer) ValidateArithmetic(leftExpr, rightExpr Expression, operator BinaryOp) error {
	leftType := sa.TypeInference.InferExpressionType(leftExpr)
	rightType := sa.TypeInference.InferExpressionType(rightExpr)
	
	switch operator {
	case PLUS, MINUS, MULTIPLY, DIVIDE:
		// 算术操作符要求两边都是数值类型
		if !sa.TypeInference.isNumericType(leftType) && leftType.Name != "UNKNOWN" {
			return fmt.Errorf("arithmetic operator requires numeric type on left side, got %s", leftType.String())
		}
		if !sa.TypeInference.isNumericType(rightType) && rightType.Name != "UNKNOWN" {
			return fmt.Errorf("arithmetic operator requires numeric type on right side, got %s", rightType.String())
		}
		return nil
	
	case MODULO:
		// 取模操作符要求两边都是整数类型
		if !sa.TypeInference.isIntegerType(leftType) && leftType.Name != "UNKNOWN" {
			return fmt.Errorf("modulo operator requires integer type on left side, got %s", leftType.String())
		}
		if !sa.TypeInference.isIntegerType(rightType) && rightType.Name != "UNKNOWN" {
			return fmt.Errorf("modulo operator requires integer type on right side, got %s", rightType.String())
		}
		return nil
	
	default:
		return nil
	}
}

// ValidateNullCheck 验证IS NULL和IS NOT NULL操作
func (sa *SemanticAnalyzer) ValidateNullCheck(expr Expression, operator BinaryOp) error {
	// IS NULL和IS NOT NULL可以应用于任何类型的表达式
	// 这里主要是确保语法正确性，类型检查相对宽松
	return nil
}

// ValidateStringConcat 验证字符串连接操作
func (sa *SemanticAnalyzer) ValidateStringConcat(leftExpr, rightExpr Expression) error {
	leftType := sa.TypeInference.InferExpressionType(leftExpr)
	rightType := sa.TypeInference.InferExpressionType(rightExpr)
	
	// 字符串连接操作符要求两边都是字符串类型或可转换为字符串的类型
	// 在PostgreSQL中，|| 操作符可以连接字符串，也可以连接数组
	// 这里简化处理，主要检查字符串类型
	if !sa.TypeInference.isStringType(leftType) && leftType.Name != "UNKNOWN" {
		// 允许数值类型自动转换为字符串
		if !sa.TypeInference.isNumericType(leftType) {
			return fmt.Errorf("string concatenation operator requires string or numeric type on left side, got %s", leftType.String())
		}
	}
	if !sa.TypeInference.isStringType(rightType) && rightType.Name != "UNKNOWN" {
		// 允许数值类型自动转换为字符串
		if !sa.TypeInference.isNumericType(rightType) {
			return fmt.Errorf("string concatenation operator requires string or numeric type on right side, got %s", rightType.String())
		}
	}
	return nil
}

// ValidateFunctionCall 验证函数调用的参数类型
func (sa *SemanticAnalyzer) ValidateFunctionCall(funcCall *FunctionCall) error {
	funcName := strings.ToUpper(funcCall.Name)
	
	// 验证常见函数的参数类型
	switch funcName {
	case "COUNT":
		// COUNT函数可以接受任何类型的参数
		return nil
	
	case "SUM", "AVG":
		// SUM和AVG函数要求数值类型参数
		if len(funcCall.Args) != 1 {
			return fmt.Errorf("%s function requires exactly one argument", funcName)
		}
		argType := sa.TypeInference.InferExpressionType(funcCall.Args[0])
		if !sa.TypeInference.isNumericType(argType) && argType.Name != "UNKNOWN" {
			return fmt.Errorf("%s function requires numeric argument, got %s", funcName, argType.String())
		}
		return nil
	
	case "MIN", "MAX":
		// MIN和MAX函数要求可比较的类型
		if len(funcCall.Args) != 1 {
			return fmt.Errorf("%s function requires exactly one argument", funcName)
		}
		// 大多数类型都可以比较，这里简化处理
		return nil
	
	case "UPPER", "LOWER", "TRIM", "LTRIM", "RTRIM":
		// 字符串函数要求字符串类型参数
		if len(funcCall.Args) != 1 {
			return fmt.Errorf("%s function requires exactly one argument", funcName)
		}
		argType := sa.TypeInference.InferExpressionType(funcCall.Args[0])
		if !sa.TypeInference.isStringType(argType) && argType.Name != "UNKNOWN" {
			return fmt.Errorf("%s function requires string argument, got %s", funcName, argType.String())
		}
		return nil
	
	case "LENGTH", "CHAR_LENGTH", "CHARACTER_LENGTH":
		// 长度函数要求字符串类型参数
		if len(funcCall.Args) != 1 {
			return fmt.Errorf("%s function requires exactly one argument", funcName)
		}
		argType := sa.TypeInference.InferExpressionType(funcCall.Args[0])
		if !sa.TypeInference.isStringType(argType) && argType.Name != "UNKNOWN" {
			return fmt.Errorf("%s function requires string argument, got %s", funcName, argType.String())
		}
		return nil
	
	case "ABS", "ROUND", "CEIL", "CEILING", "FLOOR":
		// 数学函数要求数值类型参数
		if len(funcCall.Args) != 1 {
			return fmt.Errorf("%s function requires exactly one argument", funcName)
		}
		argType := sa.TypeInference.InferExpressionType(funcCall.Args[0])
		if !sa.TypeInference.isNumericType(argType) && argType.Name != "UNKNOWN" {
			return fmt.Errorf("%s function requires numeric argument, got %s", funcName, argType.String())
		}
		return nil
	
	default:
		// 未知函数，跳过类型检查
		return nil
	}
}